home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / dbmalloc / datams.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  3KB  |  139 lines
  1.  
  2. /*
  3.  * (c) Copyright 1990, 1991, 1992 Conor P. Cahill (cpcahil@virtech.vti.com)
  4.  *
  5.  * This software may be distributed freely as long as the following conditions
  6.  * are met:
  7.  *         * the distribution, or any derivative thereof, may not be
  8.  *          included as part of a commercial product
  9.  *        * full source code is provided including this copyright
  10.  *        * there is no charge for the software itself (there may be
  11.  *          a minimal charge for the copying or distribution effort)
  12.  *        * this copyright notice is not modified or removed from any
  13.  *          source file
  14.  */
  15.  
  16. /*
  17.  * datams.c - this module contains functions designed to efficiently 
  18.  *          set memory areas to specified values in a portable fasion.
  19.  *
  20.  * The configure script will usually override this module with a copy
  21.  * of the system suplied memset() utility if it can figure out how to
  22.  * convert the module name to DataMS.
  23.  */
  24. #ifndef lint
  25. static
  26. char rcs_hdr[] = "$Id: datams.c,v 1.4 1992/08/22 16:27:13 cpcahil Exp $";
  27. #endif
  28.  
  29. #include <stdio.h>
  30. #include "mallocin.h"
  31.  
  32. typedef int word;
  33.  
  34. #define wordmask (sizeof(word)-1)
  35. #define FILL_ARRSIZ     256
  36.  
  37. void
  38. DataMS(ptr1,ch, len)
  39.     MEMDATA            * ptr1;
  40.     int              ch;
  41.     register MEMSIZE      len;
  42. {
  43.     MEMSIZE              i;
  44.     register unsigned char    * ptr;
  45.     word              fillword;
  46.     static word          fillwords[FILL_ARRSIZ] = { -1 };
  47.  
  48.     /*
  49.      * if nothing to do, return immediatly.
  50.      */
  51.     if( len <= 0 )
  52.     {
  53.         return;
  54.     }
  55.  
  56.     /*
  57.      * if we haven't filled the fillwords array
  58.      */
  59.     if( fillwords[0] == -1 )
  60.     {
  61.         int          j;
  62.         int          k;
  63.  
  64.         /*
  65.          * fill em all at this time.
  66.          */
  67.         for(k=0; k < FILL_ARRSIZ; k++)
  68.         {
  69.             ptr = (unsigned char *) &fillwords[k];
  70.             for(j=0; j < sizeof(word); j++)
  71.             {
  72.                 *(ptr++) = (unsigned char) k;
  73.             }
  74.         }
  75.     }
  76.  
  77.     /*
  78.      * if the character is outside of the proper range, use 255
  79.       */
  80.     if( ((unsigned)ch) > 0xFF )
  81.     {
  82.         ch = ((unsigned)ch) & 0xFF;
  83.     }
  84.  
  85.     /*
  86.      * save the word we will use for filling
  87.      */
  88.     fillword = fillwords[(unsigned)ch];
  89.             
  90.  
  91.     /*
  92.      * get the original pointer
  93.      */
  94.     ptr = (unsigned char *) ptr1;
  95.  
  96.     /*
  97.      * if we are not at a word offset, handle the single bytes at the
  98.      * begining of the set
  99.      */
  100.     if( (i = (((long)ptr) & wordmask)) != 0 )
  101.     {
  102.         i = sizeof(word) - i;
  103.         while( (i-- > 0) && (len > 0) )
  104.         {
  105.             *(ptr++) = ch;
  106.             len--;
  107.         }
  108.     }
  109.  
  110.     /*
  111.      * convert remaining number of bytes to number of words
  112.      */
  113.     i = len >> (sizeof(word)/2);
  114.  
  115.     /*
  116.      * and fill them
  117.      */
  118.     while( i-- )
  119.     {
  120.         *(word *)ptr = fillword;
  121.         ptr += sizeof(word);
  122.     }
  123.  
  124.     /*
  125.      * and now handle any trailing bytes
  126.      */
  127.     if( (i = (len & wordmask)) != 0 )
  128.     {
  129.         while(i-- > 0 )
  130.         {
  131.             *(ptr++) = ch;
  132.         }
  133.     }
  134.  
  135.     return;
  136.  
  137. } /* DataMS(... */
  138.  
  139.